package com.halfsword.creativecraft.utils;

import java.util.ArrayList;
import java.util.List;
import java.util.function.IntSupplier;

/**
 * ContainerData构建器
 * 用于构建模块化的ContainerData
 */
public class ContainerDataBuilder {
    private final List<IntSupplier> suppliers = new ArrayList<>();
    private final List<IntConsumer> consumers = new ArrayList<>();
    private final List<Runnable> changeListeners = new ArrayList<>();

    /**
     * 添加一个整型数据字段
     * @param supplier 数据提供者
     * @param consumer 数据消费者
     * @return 构建器实例
     */
    public ContainerDataBuilder addField(IntSupplier supplier, IntConsumer consumer) {
        suppliers.add(supplier);
        consumers.add(consumer);
        return this;
    }

    /**
     * 添加一个只读整型数据字段
     * @param supplier 数据提供者
     * @return 构建器实例
     */
    public ContainerDataBuilder addReadOnlyField(IntSupplier supplier) {
        suppliers.add(supplier);
        consumers.add(value -> {
            // 只读字段，忽略设置操作
        });
        return this;
    }

    /**
     * 添加数据变化监听器
     * @param listener 监听器
     * @return 构建器实例
     */
    public ContainerDataBuilder addChangeListener(Runnable listener) {
        changeListeners.add(listener);
        return this;
    }

    /**
     * 构建ModularContainerData
     * @return ModularContainerData实例
     */
    public ModularContainerData build() {
        return new ModularContainerData(
                new ArrayList<>(suppliers),
                new ArrayList<>(consumers),
                new ArrayList<>(changeListeners)
        );
    }

    /**
     * 获取数据字段数量
     * @return 数据字段数量
     */
    public int getFieldCount() {
        return suppliers.size();
    }

    /**
     * 获取指定索引的数据值
     * @param index 索引
     * @return 数据值
     */
    public int get(int index) {
        if (index < 0 || index >= suppliers.size()) {
            return 0;
        }
        return suppliers.get(index).getAsInt();
    }

    /**
     * 设置指定索引的数据值
     * @param index 索引
     * @param value 数据值
     */
    public void set(int index, int value) {
        if (index < 0 || index >= consumers.size()) {
            return;
        }
        consumers.get(index).accept(value);

        // 通知所有变化监听器
        for (Runnable listener : changeListeners) {
            listener.run();
        }
    }

    /**
     * 清空所有数据字段
     */
    public void clear() {
        suppliers.clear();
        consumers.clear();
        changeListeners.clear();
    }

    /**
     * 函数式接口，用于消费整型数据
     */
    @FunctionalInterface
    public interface IntConsumer {
        void accept(int value);
    }
}